package cn.itsource.ymcc.service.impl;

import cn.itsource.ymcc.constant.CacheConstants;
import cn.itsource.ymcc.domain.CourseType;
import cn.itsource.ymcc.mapper.CourseTypeMapper;
import cn.itsource.ymcc.service.ICourseTypeService;
import cn.itsource.ymcc.vo.CourseTypeCrumbsVo;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.checkerframework.checker.units.qual.A;
import org.checkerframework.checker.units.qual.C;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;
import java.util.stream.Collectors;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author zongchangjiang
 * @since 2023-03-31
 */
@Slf4j
@Service
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    //特殊规则  key  如果你用字符串必须这个写 例如"'ALL'"
    @Override
    @Cacheable(cacheNames = CacheConstants.SERVICE_COURSE_TREE,key = "'ALL'")
    public List<CourseType> treeData() {
//        if(redisTemplate.hasKey(CacheConstants.SERVICE_COURSE_TREE)){
//            return (List<CourseType>)redisTemplate.opsForValue().get(CacheConstants.SERVICE_COURSE_TREE);
//        }
        //构建树
        // 三种方式
        //    1.递归  垃圾 效率不行  会反复查询数据  数据量越大 问题越大  OOM内存溢出
        //    2.双重for循环  效率一般般  循环就是 N*N   很直观  新手很舒服
        //    3.for + hashMap  效率高  2*N
//        return recursion(0L);
//        return forTreeData();
        log.debug("1321313212312311321231231312123123123321");
        List<CourseType> courseTypes = forMapTreeData();
//        redisTemplate.opsForValue().set(CacheConstants.SERVICE_COURSE_TREE,courseTypes);
        return courseTypes;
    }

    @Override
    public List<CourseTypeCrumbsVo> loadCrumbs(Long courseTypeId) {
        //找到自己
        CourseType courseType = baseMapper.selectById(courseTypeId);
        //1037.1039.1048  分割path
        String[] split = courseType.getPath().split("\\.");//[1037,1039,1048]
        List<CourseTypeCrumbsVo> result = new ArrayList<>();
        for (String s : split) {
            //构建 CourseTypeCrumbsVo
            CourseTypeCrumbsVo courseTypeCrumbsVo = new CourseTypeCrumbsVo();
            CourseType courseType1 = null;
            if(s.equals(courseTypeId.toString())){
                courseType1 = courseType;
            }else {
                courseType1 = baseMapper.selectById(s);
            }
            courseTypeCrumbsVo.setCurrent(courseType1);//装自己
            //如果是顶级就不找兄弟
            if(courseType1.getPid() != 0){
                //找到兄弟
                List<CourseType> typeList = baseMapper.selectList(new QueryWrapper<CourseType>().eq("pid", courseType1.getPid()));
                courseTypeCrumbsVo.setBrothers(typeList);
            }
            result.add(courseTypeCrumbsVo);
        }
        return result;
    }

    @Override
    @CacheEvict(cacheNames = CacheConstants.SERVICE_COURSE_TREE,key = "'ALL'")//清除缓存
    public boolean save(CourseType entity) {
//        redisTemplate.delete(CacheConstants.SERVICE_COURSE_TREE);
        return super.save(entity);
    }

    @Override
    @CacheEvict(cacheNames = CacheConstants.SERVICE_COURSE_TREE,key = "'ALL'")//清除缓存
    public boolean updateById(CourseType entity) {
//        redisTemplate.delete(CacheConstants.SERVICE_COURSE_TREE);
        return super.updateById(entity);
    }

    @Override
    @CacheEvict(cacheNames = CacheConstants.SERVICE_COURSE_TREE,key = "'ALL'")//清除缓存
    public boolean removeById(Serializable id) {
//        redisTemplate.delete(CacheConstants.SERVICE_COURSE_TREE);
        return super.removeById(id);
    }



    /**
     * 最优秀的一种
     * @return
     */
    private List<CourseType> forMapTreeData(){
        List<CourseType> courseTypes = baseMapper.selectList(null);
        List<CourseType> one = new ArrayList<>();
        //将list转为map
        Map<Long,CourseType> map = new HashMap<>();
        for (CourseType courseType : courseTypes) {
            map.put(courseType.getId(),courseType);
        }

        for (CourseType courseType : courseTypes) {
            if(courseType.getPid().longValue() == 0L){
                one.add(courseType);
            }else {
                CourseType courseType1 = map.get(courseType.getPid());
                courseType1.getChildren().add(courseType);
            }
        }
        return one;
    }

    private List<CourseType> forTreeData(){
        List<CourseType> courseTypes = baseMapper.selectList(null);
        List<CourseType> one = new ArrayList<>();
        for (CourseType courseType : courseTypes) {
            if(courseType.getPid().longValue() == 0L){
                one.add(courseType);
            }else {
                for (CourseType type : courseTypes) {
                    if(courseType.getPid().equals(type.getId())){
                        type.getChildren().add(courseType);
                        break;
                    }
                }
            }
        }
        return one;
    }

    /**
     *  看球不懂
     * @param id 顶级id
     * @return
     */
    private List<CourseType> recursion(Long id){
        //顶级查询出来
        List<CourseType> pid = baseMapper.selectList(new QueryWrapper<CourseType>().eq("pid", id));
        //有一种特情况 就我去查询的时候 已经没有儿子
        if(pid != null && pid.size() > 0){
            for (CourseType courseType : pid) {
                courseType.setChildren(recursion(courseType.getId()));
            }
        }
        return pid;
    }
}
